#! /usr/bin/env python
# -*- coding: utf-8 -*-

"""
Модуль осуществляет поиск по методу Гзовского ориентации 
векторов главных напряжений по заданным ориентировкам 
двух сопряженных плоскостей.
L1 - ось сжатия, L2 - промежуточная ось, L3 - ось растяжения
"""

import sys
from optparse import OptionParser
from plane import Plane
import fr_parser

def f(a, b):
    # Функция возвращает True если a впереди попходу часовой стрелки от b
    return (a-b)%360<180
def f2(a, b, c):
    # Функция возвращает True если a,b,c стоят друг за другом по часовой стрлке
    list = [a,b,c]
    list.sort()
    if list==[a,b,c] or list==[b,c,a] or list==[c,a,b]:
        return True
    else:
        return False

# Parsing of an options
optparser= OptionParser()
optparser.add_option('-o', '--output filename', dest='ofile',
                     help='Name of a file to put the results in a \
					 str_canvas format')                     
optparser.add_option('-c', dest='dirs',
					help='Read directions in files', 
					action='store_true',
                    default=False)				
options, args = optparser.parse_args(sys.argv[1:])

lines = sys.stdin.read().split('\n')

# Разбор введенных данных и создание двух плоскостей Sc1 и Sc2.
data=[]
for line in lines:
    val = fr_parser.parse_line(line)
    if val: data.append(val)    
Sc1 = Plane(int(data[0][0]), int(data[0][1]))
Sc2 = Plane(int(data[1][0]), int(data[1][1]))
if options.dirs:
    dir2 = int(data[1][2])
    dir1 = int(data[0][2])

# Находим линию пересечения сопряженных плоскостей.
Sc1_n = Sc1.normal()
Sc2_n = Sc2.normal()
pplane = Sc1_n.get_perpendicular_between(Sc2_n).normal()

if options.dirs:
    # Если задана опция -c, то сразу определяем куда смещены векторы.
    Sc1v = Plane(dir1, 10)
    ppSc1v = Sc1_n.get_perpendicular_between(Sc1v).normal()
    Sc2v = Plane(dir2, 10)
    ppSc2v = Sc2_n.get_perpendicular_between(Sc2v).normal()
    # ppSc1v - плоскость вдоль которой направлено смещение 



# Вращаем pplane вместе с нормалями к сопряженным плоскостям так, чтобы pplane лежала в горизонтальной плоскости
rotatedir = pplane.dir
rotatedip = pplane.dip
pplane.rotate_cos2(-rotatedir); pplane=pplane.normal()
Sc2_n.rotate_cos2(-rotatedir); Sc2_n = Sc2_n.normal()
Sc1_n.rotate_cos2(-rotatedir); Sc1_n = Sc1_n.normal()

pplane.rotate_cos3(-rotatedip); pplane=pplane.normal()
Sc1_n.rotate_cos3(-rotatedip); Sc1_n = Sc1_n.normal()
Sc2_n.rotate_cos3(-rotatedip); Sc2_n = Sc2_n.normal()

# Поворачиваем сопряженные плоскости так, чтобы биссектриса между ними совпала с осью cos1
angle = (Sc1_n.dir - Sc2_n.dir) % 360
rotateangle = Sc1_n.dir - angle/2
Sc1_n.rotate_cos2(-rotateangle); Sc1_n = Sc1_n.normal()
Sc2_n.rotate_cos2(-rotateangle); Sc2_n = Sc2_n.normal()


Sc1_n_ = Plane(Sc1_n.dir, Sc1_n.dip)
Sc2_n_ = Plane(Sc2_n.dir, Sc2_n.dip)
pplane_= Plane(pplane.dir, pplane.dip)

# Теперь ось L_2 направлена строго вверх, а оси L_1 и L_3 соноправленны с осями cos1, cos3. 
# Осталось выяснить которая из них какая.
# Если не задано ни каких опций, то ось сжатия (L_1) должна лежать в биссектрисе острого угла.
# Если задана опция -с, то ориентируемся на направления смещений.

if not options.dirs:
    # Опции не заданы. 
    # cos1 - острый угол.
    L_1 = Plane( 0, 0)
    L_2 = Plane( 0,90)
    L_3 = Plane(90, 0)
else:
    # Опция -с задана. Определяем куда смещены векторы
    ppSc1v.rotate_cos2(-rotatedir); ppSc1v = ppSc1v.normal()
    Sc1v.  rotate_cos2(-rotatedir);   Sc1v = Sc1v.normal()
    ppSc2v.rotate_cos2(-rotatedir); ppSc2v = ppSc2v.normal()
    Sc2v.  rotate_cos2(-rotatedir);   Sc2v = Sc2v.normal()

    ppSc1v.rotate_cos3(-rotatedip); ppSc1v = ppSc1v.normal()
    Sc1v.  rotate_cos3(-rotatedip);   Sc1v = Sc1v.normal()
    ppSc2v.rotate_cos3(-rotatedip); ppSc2v = ppSc2v.normal()
    Sc2v.  rotate_cos3(-rotatedip);   Sc2v = Sc2v.normal()

    ppSc1v.rotate_cos2(-rotateangle); ppSc1v = ppSc1v.normal()
    Sc1v.  rotate_cos2(-rotateangle); Sc1v   = Sc1v.normal()
    ppSc2v.rotate_cos2(-rotateangle); ppSc2v = ppSc2v.normal()
    Sc2v.  rotate_cos2(-rotateangle); Sc2v =   Sc2v.normal()

    if f2(Sc1_n.dir,Sc1v.dir,(Sc1_n.dir+180)%360) and \
       f2((Sc2_n.dir+180)%360,Sc2v.dir,Sc2_n.dir): 
        # направлены в стороны друг от друга <--*  *-->
        L_1 = Plane(90, 0)
        L_2 = Plane( 0,90)
        L_3 = Plane( 0, 0)
    elif f2(Sc2_n.dir,Sc2v.dir,(Sc2_n.dir+180)%360) and \
       f2((Sc1_n.dir+180)%360,Sc1v.dir,Sc1_n.dir): 
        # направлены друг к другу            *-->  <--*
        L_1 = Plane( 0, 0)
        L_2 = Plane( 0,90)
        L_3 = Plane(90, 0)
    else:
        sys.stderr.write('error\n')
        sys.exit()

# Разварачиваем все обратно
Sc1_n.rotate_cos2(rotateangle); Sc1_n = Sc1_n.normal()
Sc2_n.rotate_cos2(rotateangle); Sc2_n = Sc2_n.normal()
L_1.rotate_cos2(rotateangle); L_1 = L_1.normal()
L_2.rotate_cos2(rotateangle); L_2 = L_2.normal()
L_3.rotate_cos2(rotateangle); L_3 = L_3.normal()

Sc1_n.rotate_cos3(rotatedip); Sc1_n = Sc1_n.normal()
Sc2_n.rotate_cos3(rotatedip); Sc2_n = Sc2_n.normal()
L_1.rotate_cos3(rotatedip); L_1 = L_1.normal()
L_2.rotate_cos3(rotatedip); L_2 = L_2.normal()
L_3.rotate_cos3(rotatedip); L_3 = L_3.normal()
pplane.rotate_cos3(rotatedip); pplane=pplane.normal()

Sc1_n.rotate_cos2(rotatedir); Sc1_n = Sc1_n.normal()
Sc2_n.rotate_cos2(rotatedir); Sc2_n = Sc2_n.normal()
L_1.rotate_cos2(rotatedir); L_1 = L_1.normal()
L_2.rotate_cos2(rotatedir); L_2 = L_2.normal()
L_3.rotate_cos2(rotatedir); L_3 = L_3.normal()
pplane.rotate_cos2(rotatedir); pplane=pplane.normal()

# Проверяем положение линий в нижней полусфере
if L_1.dip < 0 :
    L_1.dip=-1*L_1.dip
    L_1.dir+=180
    L_1.dir=L_1.dir%360
if L_2.dip < 0 :
    L_2.dip=-1*L_2.dip
    L_2.dir+=180
    L_2.dir=L_2.dir%360
if L_3.dip < 0 :
    L_3.dip=-1*L_3.dip
    L_3.dir+=180
    L_3.dir=L_3.dir%360


if options.ofile and not options.dirs:
    f = open(options.ofile, 'w')
    f.write('%003d %02d l\n' % (Sc1.dir, Sc1.dip))
    f.write('%003d %02d l\n' % (Sc2.dir, Sc2.dip))
    f.write('%003d %02d pz 0,0,1\n' % (L_1.dir, L_1.dip))
    f.write('%003d %02d pz 0.5,0,0.5\n' % (L_2.dir, L_2.dip))
    f.write('%003d %02d pz 1,0,0\n' % (L_3.dir, L_3.dip))
    f.close
elif options.ofile and options.dirs:
    f = open(options.ofile, 'w')
    f.write('%003d %02d l\n' % (Sc1.dir, Sc1.dip))
    f.write('%003d %02d l\n' % (Sc2.dir, Sc2.dip))
    f.write('%003d 90 l\n' % (Sc1.dir))
    f.write('%003d 90 l\n' % (Sc2.dir))
    # draw small arrows
    if L_2.dip < 21:
        # draw just one aroow
        A = (Sc1.dir-90)%360
        B = (Sc1.dir+90)%360
        if (B-dir1)%360<180 and (A-dir1)%360>180:
            f.write('%003d %02d %003d w\n' % (Sc1.dir, Sc1.dip, Sc1.dir))
        else:
            f.write('%003d %02d %003d w\n' % (Sc1.dir, Sc1.dip, (Sc1.dir+180)%360))
        A = (Sc2.dir-90)%360
        B = (Sc2.dir+90)%360
        if (B-dir2)%360<180 and (A-dir2)%360>180:
            f.write('%003d %02d %003d w\n' % (Sc2.dir, Sc2.dip, Sc2.dir))
        else:
            f.write('%003d %02d %003d w\n' % (Sc2.dir, Sc2.dip, (Sc2.dir+180)%360))
    else:    
        if (Sc1.dir - dir1) % 360 < 180:
            # Sc1 turned conterclokwise
            Sc1rotate = Sc1.rotated(-65)
            f.write('%003d %02d %003d w\n' % (Sc1rotate.dir, Sc1rotate.dip, (Sc1.dir-135)%360))
            Sc1rotate = Sc1.rotated(65)
            f.write('%003d %02d %003d w\n' % (Sc1rotate.dir, Sc1rotate.dip, (Sc1.dir-45)%360))
        else:
            # Sc1 turned clokwise
            Sc1rotate = Sc1.rotated(65)
            f.write('%003d %02d %003d w\n' % (Sc1rotate.dir, Sc1rotate.dip, (Sc1.dir-135)%360))
            Sc1rotate = Sc1.rotated(-65)
            f.write('%003d %02d %003d w\n' % (Sc1rotate.dir, Sc1rotate.dip, (Sc1.dir-45)%360))
        if (Sc2.dir - dir2) % 360 < 180:
            # Sc1 turned conterclokwise
            Sc2rotate = Sc2.rotated(-65)
            f.write('%003d %02d %003d w\n' % (Sc2rotate.dir, Sc2rotate.dip, (Sc2.dir-135)%360))
            Sc2rotate = Sc2.rotated(65)
            f.write('%003d %02d %003d w\n' % (Sc2rotate.dir, Sc2rotate.dip, (Sc2.dir-45)%360))
        else:
            # Sc1 turned clokwise
            Sc2rotate = Sc2.rotated(65)
            f.write('%003d %02d %003d w\n' % (Sc2rotate.dir, Sc2rotate.dip, (Sc2.dir-135)%360))
            Sc2rotate = Sc2.rotated(-65)
            f.write('%003d %02d %003d w\n' % (Sc2rotate.dir, Sc2rotate.dip, (Sc2.dir-45)%360))
    f.write('%003d %02d pz 0,0,1\n' % (L_1.dir, L_1.dip))
    f.write('%003d %02d pz 0.5,0,0.5\n' % (L_2.dir, L_2.dip))
    f.write('%003d %02d pz 1,0,0\n' % (L_3.dir, L_3.dip))
    f.close
# Вывод результата на экран
sys.stdout.write('sigma1   sigma2   sigma3\n')
sys.stdout.write('%003d %02d   %003d %02d   %003d %02d\n' % (L_1.dir, L_1.dip, L_2.dir, L_2.dip, L_3.dir, L_3.dip))
